This patch introduces the MatrixMatrix multiplication logic. It performs a
shuffle-based matrix multiplication on two large matrix streams.

Implementation Detail:

Asynchronous Producer: The processInstruction method launches a background
thread to perform the entire two-phase multiplication, but returns control
to the main thread immediately. This non-blocking setup allows the compiler
to build the downstream executionplan while the OOC operation prepares to run
upon data request.

Two-Phase Streaming Logic: The background thread implements a shuffle-based
algorithm to handle two large inputs:

    * Phase 1 (Grouping/Shuffle): It first consumes both input streams entirely.
     Blocks from each stream (A_ik and B_kj) are partitioned into groups based
     on the output block index (C_ij) they contribute to. A HashMap stores these
     groups, effectively "shuffling" the data for parallel processing.

    * Phase 2 (Aggregation/Reduce): After grouping, it processes each group
    independently. Within a group, it pairs the corresponding blocks using their
    common index k, performs the block-level multiplication, and aggregates the
    results to produce a single, final output block which is then enqueued to
    theoutput stream.

Robust Block Identification: A TaggedMatrixValue wrapper is used during the grouping
phase to explicitly tag each block with its source matrix (A or B).
This ensures correct and unambiguous identification during the aggregation phase,
a critical requirement that cannot be met by relying on block dimensions alone.

Integration: The new instruction is fully integrated into the OOC framework:
  * The OOCInstructionParser is updated to recognize the aggregate binary in OOC context.